feat(libtorch): report device identity per index - #35

Stacked on #36

This branch carries #36's three commits first; this PR's own are the last two. #36 gives the
bridge its host device, and this PR's queries must say what they do there, so the two are checked
together. Merging #36 first leaves this PR with its own two commits.

What

Runtime.Autograd.LibTorch.deviceInfo (index : UInt32) : IO DeviceInfo and
currentDeviceInfo, the LibTorch follow-up to #30: name, compute capability (major * 10 + minor, so 86 reads as sm_86), SM count, core and memory clocks, memory bus width, total
memory, and the driver and runtime versions, plus DeviceInfo.peakBandwidthGBs and a one-line
DeviceInfo.format for a benchmark header. Buffer.memory answers how much device memory there
is; this answers which device.

The review finding from #30

#30 cached one cudaDeviceProp under a process-wide pthread_once, so after switching devices
it kept reporting device 0 and could combine fields from two cards. Here every query takes an
explicit index and reads at::cuda::getDeviceProperties(index), the SDK's own per-device cache,
so the answer never depends on which device was selected earlier; currentDeviceInfo is
deviceInfo (← getDevice). The test switches through every visible device in a fresh process
and checks that currentDeviceInfo reports each index in turn.

Clocks and bus width come from cudaDeviceGetAttribute, since CUDA 13 removed clockRate and
memoryClockRate from cudaDeviceProp and the attribute enums exist in 12.x and 13.x. An index
at or above device_count is a TORCH_CHECK failure that surfaces as an IO error, like every
other runtime control; the build without LibTorch fails the same way through unavailable.c
rather than returning a record of zeroes. On a CPU-only SDK, where cudaDeviceProp does not
exist, the exports compile under TORCHLEAN_LIBTORCH_CUDA and fail through IO the same way. A
CUDA-enabled SDK answers even while the bridge runs on the host: the queries describe the visible
devices, not the selected one.

What is not carried over

#30 also reported the architectures the binary held native code for (__CUDA_ARCH_LIST__) and
warned when the device was being served through PTX JIT. Neither carries over, for two separate
reasons the module docstring keeps apart. The SDK's packaged architectures are a property of the
SDK build, and ATen's C++ API does not expose the list (only the Python package reads it back).
The kernels TorchLean compiles itself, the generated operations of NN.Kernel, are compiled at
run time by NVRTC for the compute capability of the device they run on, so there is no
compiled-in architecture list for them to report.

Tests

NN/Tests/Runtime/Cuda/DeviceInfo.lean, called from NN/Tests/Suite.lean under every runtime
status:

• with a device: every visible index reports itself, a nonempty name, a nonzero capability, SM
  count, and memory; currentDeviceInfo agrees with getDevice; the index at the visible count
  is rejected; and a child process (TORCHLEAN_LIBTORCH_DEVICE_PROBE=switch, the pattern of the
  memory probes) walks setDevice through every device before any buffer exists, because
  setDevice refuses while wrappers are live;
• with the bridge on the host and a CUDA-enabled SDK: the readback alone, since the host rejects
  setDevice; the switching probe requires a CUDA device (Buffer.requireCudaDevice, from feat(libtorch): run the bridge on the host when the SDK is CPU-only #36);
• on a CPU-only SDK, and without LibTorch: deviceInfo 0 fails.

Checks run

RTX A4500 (sm_86, driver 580.126), pip torch 2.11.0+cu128 with a CUDA 12.8 toolkit for SDK
discovery and NVRTC, and pip torch 2.11.0+cpu with no toolkit; Lean v4.35.0, on cfbcb9a5:

lake -R -Kcuda=true build nn_tests_suite (either SDK)          Build completed successfully (8535 jobs).
TORCHLEAN_REQUIRE_CUDA=1 nn_tests_suite                        == TorchLean: all curated tests passed ==
  same binary, TORCHLEAN_LIBTORCH_DEVICE=cpu                   == TorchLean: all curated tests passed ==
  CPU-only SDK build, TORCHLEAN_REQUIRE_NATIVE=1               == TorchLean: all curated tests passed ==
lake -R -Kcuda=false build NN NNTests nn_tests_suite NNCI NNExamples   Build completed successfully (10204 jobs).
nn_tests_suite (default build)                                 device identity: queries are rejected without LibTorch
                                                               == TorchLean: all curated tests passed ==
python3 scripts/checks/repo_lint.py --fail-on-warn             OK: no issues found.

Device-identity section of the GPU run:

== LibTorch device identity ==
  NVIDIA RTX A4500 (device 0, sm_86, 56 SMs, 19.548828 GiB, ~640.080000 GB/s peak, driver 13.0, runtime 12.8)
  device switching: 1 device(s) report under their own index

On the host with the same binary the record is the same and the switching probe reads
skipped: the device switching probe needs the bridge on a CUDA device; on the CPU-only SDK,
device identity: queries are rejected on a CPU-only SDK.

Not run: the sanitizer harness and the elementwise C++ harness. This host has one GPU, so the
switching probe exercised one index; the multi-device case is covered by construction (per-index
reads) rather than by an observation.